/*
 * Copyright Codeplay Software Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use these files except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// DO NOT MODIFY BY HAND
// This file was automatically generated by generate_conv2d_tests.py.
// Results calculated using Tensorflow v1.12.0.

#include <gtest/gtest.h>

#include "sycldnn/padding_mode.h"

#include "test/types/cartesian_product.h"
#include "test/types/kernel_data_types.h"
#include "test/types/nested_pairs_to_triple.h"
#include "test/types/test_backend_types.h"
#include "test/types/to_gtest_types.h"

#include "test/conv2d/selector_list.h"
#include "test/conv2d/window_stride_fixture.h"

#include <array>
#include <vector>

using DataTypeList = sycldnn::types::KernelDataTypes;
using Selectors = sycldnn::types::SelectorList;
using Backends = sycldnn::types::AllBackendTypes;

using SNNTypePairs =
    sycldnn::types::CartesianProduct<Selectors, DataTypeList>::type;
using BackendTypePairs =
    sycldnn::types::CartesianProduct<SNNTypePairs, Backends>::type;
using TestTriples = sycldnn::types::NestedPairsToTriple<BackendTypePairs>::type;

using GTestTypeTriples = sycldnn::types::ToGTestTypes<TestTriples>::type;

template <typename Pair>
using FilterBackpropWindow1Stride1 = WindowStrideTest<Pair, 1, 1>;
TYPED_TEST_SUITE(FilterBackpropWindow1Stride1, GTestTypeTriples);
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {30.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50., 60.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50., 60.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {90., 100., 110., 120.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {90., 100., 110., 120.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50., 60.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {50., 60.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {84., 100., 100., 120.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {84., 100., 100., 120.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {152., 168., 184., 200.,
                                         180., 200., 220., 240.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {152., 168., 184., 200.,
                                         180., 200., 220., 240.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {90., 100., 110., 120.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {90., 100., 110., 120.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {152., 180., 168., 200.,
                                         184., 220., 200., 240.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {152., 180., 168., 200.,
                                         184., 220., 200., 240.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {276., 304., 332., 360., 304., 336.,
                                         368., 400., 332., 368., 404., 440.,
                                         360., 400., 440., 480.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {276., 304., 332., 360., 304., 336.,
                                         368., 400., 332., 368., 404., 440.,
                                         360., 400., 440., 480.};
  const std::array<int, 4> in_shape = {{1, 2, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {91.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {91.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {161., 182.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {161., 182.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {301., 322., 343., 364.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {301., 322., 343., 364.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {161., 182.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {161., 182.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {286., 322., 322., 364.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {286., 322., 322., 364.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {536., 572., 608., 644.,
                                         602., 644., 686., 728.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {536., 572., 608., 644.,
                                         602., 644., 686., 728.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {301., 322., 343., 364.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {301., 322., 343., 364.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {536., 602., 572., 644.,
                                         608., 686., 644., 728.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {536., 602., 572., 644.,
                                         608., 686., 644., 728.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1006., 1072., 1138., 1204., 1072., 1144., 1216., 1288.,
      1138., 1216., 1294., 1372., 1204., 1288., 1372., 1456.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1006., 1072., 1138., 1204., 1072., 1144., 1216., 1288.,
      1138., 1216., 1294., 1372., 1204., 1288., 1372., 1456.};
  const std::array<int, 4> in_shape = {{1, 2, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {204.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {204.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {372., 408.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {372., 408.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {708., 744., 780., 816.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {708., 744., 780., 816.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {372., 408.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {372., 408.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {680., 744., 744., 816.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {680., 744., 744., 816.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1296., 1360., 1424., 1488.,
                                         1416., 1488., 1560., 1632.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1296., 1360., 1424., 1488.,
                                         1416., 1488., 1560., 1632.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {708., 744., 780., 816.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {708., 744., 780., 816.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1296., 1416., 1360., 1488.,
                                         1424., 1560., 1488., 1632.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1296., 1416., 1360., 1488.,
                                         1424., 1560., 1488., 1632.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x2x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2472., 2592., 2712., 2832., 2592., 2720., 2848., 2976.,
      2712., 2848., 2984., 3120., 2832., 2976., 3120., 3264.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x2x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2472., 2592., 2712., 2832., 2592., 2720., 2848., 2976.,
      2712., 2848., 2984., 3120., 2832., 2976., 3120., 3264.};
  const std::array<int, 4> in_shape = {{1, 2, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {91.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {91.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {161., 182.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {161., 182.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {301., 322., 343., 364.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {301., 322., 343., 364.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {161., 182.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {161., 182.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {286., 322., 322., 364.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {286., 322., 322., 364.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {536., 572., 608., 644.,
                                         602., 644., 686., 728.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {536., 572., 608., 644.,
                                         602., 644., 686., 728.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {301., 322., 343., 364.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {301., 322., 343., 364.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {536., 602., 572., 644.,
                                         608., 686., 644., 728.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {536., 602., 572., 644.,
                                         608., 686., 644., 728.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1006., 1072., 1138., 1204., 1072., 1144., 1216., 1288.,
      1138., 1216., 1294., 1372., 1204., 1288., 1372., 1456.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      1006., 1072., 1138., 1204., 1072., 1144., 1216., 1288.,
      1138., 1216., 1294., 1372., 1204., 1288., 1372., 1456.};
  const std::array<int, 4> in_shape = {{1, 3, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {285.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {285.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {525., 570.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {525., 570.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1005., 1050., 1095., 1140.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1005., 1050., 1095., 1140.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {525., 570.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {525., 570.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {969., 1050., 1050., 1140.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {969., 1050., 1050., 1140.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1857., 1938., 2019., 2100.,
                                         2010., 2100., 2190., 2280.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1857., 1938., 2019., 2100.,
                                         2010., 2100., 2190., 2280.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1005., 1050., 1095., 1140.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1005., 1050., 1095., 1140.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1857., 2010., 1938., 2100.,
                                         2019., 2190., 2100., 2280.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1857., 2010., 1938., 2100.,
                                         2019., 2190., 2100., 2280.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3561., 3714., 3867., 4020., 3714., 3876., 4038., 4200.,
      3867., 4038., 4209., 4380., 4020., 4200., 4380., 4560.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      3561., 3714., 3867., 4020., 3714., 3876., 4038., 4200.,
      3867., 4038., 4209., 4380., 4020., 4200., 4380., 4560.};
  const std::array<int, 4> in_shape = {{1, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {650.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {650.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1222., 1300.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1222., 1300.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2366., 2444., 2522., 2600.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2366., 2444., 2522., 2600.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1222., 1300.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1222., 1300.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2300., 2444., 2444., 2600.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2300., 2444., 2444., 2600.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4456., 4600., 4744., 4888.,
                                         4732., 4888., 5044., 5200.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4456., 4600., 4744., 4888.,
                                         4732., 4888., 5044., 5200.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2366., 2444., 2522., 2600.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2366., 2444., 2522., 2600.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4456., 4732., 4600., 4888.,
                                         4744., 5044., 4888., 5200.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4456., 4732., 4600., 4888.,
                                         4744., 5044., 4888., 5200.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8636., 8912., 9188., 9464.,  8912., 9200., 9488.,  9776.,
      9188., 9488., 9788., 10088., 9464., 9776., 10088., 10400.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8636., 8912., 9188., 9464.,  8912., 9200., 9488.,  9776.,
      9188., 9488., 9788., 10088., 9464., 9776., 10088., 10400.};
  const std::array<int, 4> in_shape = {{1, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {204.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {204.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {372., 408.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {372., 408.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {708., 744., 780., 816.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {708., 744., 780., 816.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {372., 408.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {372., 408.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {680., 744., 744., 816.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {680., 744., 744., 816.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1296., 1360., 1424., 1488.,
                                         1416., 1488., 1560., 1632.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1296., 1360., 1424., 1488.,
                                         1416., 1488., 1560., 1632.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {708., 744., 780., 816.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {708., 744., 780., 816.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1296., 1416., 1360., 1488.,
                                         1424., 1560., 1488., 1632.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1296., 1416., 1360., 1488.,
                                         1424., 1560., 1488., 1632.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2472., 2592., 2712., 2832., 2592., 2720., 2848., 2976.,
      2712., 2848., 2984., 3120., 2832., 2976., 3120., 3264.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      2472., 2592., 2712., 2832., 2592., 2720., 2848., 2976.,
      2712., 2848., 2984., 3120., 2832., 2976., 3120., 3264.};
  const std::array<int, 4> in_shape = {{1, 4, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {650.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {650.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1222., 1300.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1222., 1300.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2366., 2444., 2522., 2600.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2366., 2444., 2522., 2600.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1222., 1300.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1222., 1300.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2300., 2444., 2444., 2600.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2300., 2444., 2444., 2600.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4456., 4600., 4744., 4888.,
                                         4732., 4888., 5044., 5200.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4456., 4600., 4744., 4888.,
                                         4732., 4888., 5044., 5200.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2366., 2444., 2522., 2600.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2366., 2444., 2522., 2600.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4456., 4732., 4600., 4888.,
                                         4744., 5044., 4888., 5200.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4456., 4732., 4600., 4888.,
                                         4744., 5044., 4888., 5200.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8636., 8912., 9188., 9464.,  8912., 9200., 9488.,  9776.,
      9188., 9488., 9788., 10088., 9464., 9776., 10088., 10400.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8636., 8912., 9188., 9464.,  8912., 9200., 9488.,  9776.,
      9188., 9488., 9788., 10088., 9464., 9776., 10088., 10400.};
  const std::array<int, 4> in_shape = {{1, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1496.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1496.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2856., 2992.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2856., 2992.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5576., 5712., 5848., 5984.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5576., 5712., 5848., 5984.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2856., 2992.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2856., 2992.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5456., 5712., 5712., 5984.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5456., 5712., 5712., 5984.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {10656., 10912., 11168., 11424.,
                                         11152., 11424., 11696., 11968.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {10656., 10912., 11168., 11424.,
                                         11152., 11424., 11696., 11968.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5576., 5712., 5848., 5984.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {5576., 5712., 5848., 5984.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {10656., 11152., 10912., 11424.,
                                         11168., 11696., 11424., 11968.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {10656., 11152., 10912., 11424.,
                                         11168., 11696., 11424., 11968.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20816., 21312., 21808., 22304., 21312., 21824., 22336., 22848.,
      21808., 22336., 22864., 23392., 22304., 22848., 23392., 23936.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID1x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      20816., 21312., 21808., 22304., 21312., 21824., 22336., 22848.,
      21808., 22336., 22864., 23392., 22304., 22848., 23392., 23936.};
  const std::array<int, 4> in_shape = {{1, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {650.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {650.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1222., 1300.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1222., 1300.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2366., 2444., 2522., 2600.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2366., 2444., 2522., 2600.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1222., 1300.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {1222., 1300.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2300., 2444., 2444., 2600.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2300., 2444., 2444., 2600.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4456., 4600., 4744., 4888.,
                                         4732., 4888., 5044., 5200.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4456., 4600., 4744., 4888.,
                                         4732., 4888., 5044., 5200.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2366., 2444., 2522., 2600.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2366., 2444., 2522., 2600.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4456., 4732., 4600., 4888.,
                                         4744., 5044., 4888., 5200.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4456., 4732., 4600., 4888.,
                                         4744., 5044., 4888., 5200.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8636., 8912., 9188., 9464.,  8912., 9200., 9488.,  9776.,
      9188., 9488., 9788., 10088., 9464., 9776., 10088., 10400.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      8636., 8912., 9188., 9464.,  8912., 9200., 9488.,  9776.,
      9188., 9488., 9788., 10088., 9464., 9776., 10088., 10400.};
  const std::array<int, 4> in_shape = {{3, 2, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2109.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2109.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4047., 4218.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4047., 4218.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7923., 8094., 8265., 8436.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7923., 8094., 8265., 8436.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4047., 4218.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4047., 4218.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7770., 8094., 8094., 8436.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7770., 8094., 8094., 8436.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15216., 15540., 15864., 16188.,
                                         15846., 16188., 16530., 16872.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15216., 15540., 15864., 16188.,
                                         15846., 16188., 16530., 16872.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7923., 8094., 8265., 8436.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7923., 8094., 8265., 8436.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15216., 15846., 15540., 16188.,
                                         15864., 16530., 16188., 16872.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15216., 15846., 15540., 16188.,
                                         15864., 16530., 16188., 16872.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29802., 30432., 31062., 31692., 30432., 31080., 31728., 32376.,
      31062., 31728., 32394., 33060., 31692., 32376., 33060., 33744.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29802., 30432., 31062., 31692., 30432., 31080., 31728., 32376.,
      31062., 31728., 32394., 33060., 31692., 32376., 33060., 33744.};
  const std::array<int, 4> in_shape = {{3, 2, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4900.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4900.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {9500., 9800.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {9500., 9800.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {18700., 19000., 19300., 19600.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {18700., 19000., 19300., 19600.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {9500., 9800.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {9500., 9800.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {18424., 19000., 19000., 19600.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {18424., 19000., 19000., 19600.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {36272., 36848., 37424., 38000.,
                                         37400., 38000., 38600., 39200.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {36272., 36848., 37424., 38000.,
                                         37400., 38000., 38600., 39200.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {18700., 19000., 19300., 19600.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {18700., 19000., 19300., 19600.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {36272., 37400., 36848., 38000.,
                                         37424., 38600., 38000., 39200.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {36272., 37400., 36848., 38000.,
                                         37424., 38600., 38000., 39200.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x2x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      71416., 72544., 73672., 74800., 72544., 73696., 74848., 76000.,
      73672., 74848., 76024., 77200., 74800., 76000., 77200., 78400.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x2x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      71416., 72544., 73672., 74800., 72544., 73696., 74848., 76000.,
      73672., 74848., 76024., 77200., 74800., 76000., 77200., 78400.};
  const std::array<int, 4> in_shape = {{3, 2, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2109.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {2109.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4047., 4218.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4047., 4218.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7923., 8094., 8265., 8436.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7923., 8094., 8265., 8436.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4047., 4218.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4047., 4218.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7770., 8094., 8094., 8436.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7770., 8094., 8094., 8436.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15216., 15540., 15864., 16188.,
                                         15846., 16188., 16530., 16872.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15216., 15540., 15864., 16188.,
                                         15846., 16188., 16530., 16872.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7923., 8094., 8265., 8436.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {7923., 8094., 8265., 8436.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15216., 15846., 15540., 16188.,
                                         15864., 16530., 16188., 16872.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {15216., 15846., 15540., 16188.,
                                         15864., 16530., 16188., 16872.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29802., 30432., 31062., 31692., 30432., 31080., 31728., 32376.,
      31062., 31728., 32394., 33060., 31692., 32376., 33060., 33744.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      29802., 30432., 31062., 31692., 30432., 31080., 31728., 32376.,
      31062., 31728., 32394., 33060., 31692., 32376., 33060., 33744.};
  const std::array<int, 4> in_shape = {{3, 3, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6930.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {6930.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13482., 13860.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13482., 13860.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {26586., 26964., 27342., 27720.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {26586., 26964., 27342., 27720.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13482., 13860.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {13482., 13860.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {26235., 26964., 26964., 27720.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {26235., 26964., 26964., 27720.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {51741., 52470., 53199., 53928.,
                                         53172., 53928., 54684., 55440.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {51741., 52470., 53199., 53928.,
                                         53172., 53928., 54684., 55440.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {26586., 26964., 27342., 27720.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {26586., 26964., 27342., 27720.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {51741., 53172., 52470., 53928.,
                                         53199., 54684., 53928., 55440.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {51741., 53172., 52470., 53928.,
                                         53199., 54684., 53928., 55440.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      102051., 103482., 104913., 106344., 103482., 104940., 106398., 107856.,
      104913., 106398., 107883., 109368., 106344., 107856., 109368., 110880.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      102051., 103482., 104913., 106344., 103482., 104940., 106398., 107856.,
      104913., 106398., 107883., 109368., 106344., 107856., 109368., 110880.};
  const std::array<int, 4> in_shape = {{3, 3, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {16206.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {16206.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {31746., 32412.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {31746., 32412.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {62826., 63492., 64158., 64824.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {62826., 63492., 64158., 64824.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {31746., 32412.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {31746., 32412.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {62196., 63492., 63492., 64824.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {62196., 63492., 63492., 64824.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {123096., 124392., 125688., 126984.,
                                         125652., 126984., 128316., 129648.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {123096., 124392., 125688., 126984.,
                                         125652., 126984., 128316., 129648.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {62826., 63492., 64158., 64824.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {62826., 63492., 64158., 64824.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {123096., 125652., 124392., 126984.,
                                         125688., 128316., 126984., 129648.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {123096., 125652., 124392., 126984.,
                                         125688., 128316., 126984., 129648.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      243636., 246192., 248748., 251304., 246192., 248784., 251376., 253968.,
      248748., 251376., 254004., 256632., 251304., 253968., 256632., 259296.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x3x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      243636., 246192., 248748., 251304., 246192., 248784., 251376., 253968.,
      248748., 251376., 254004., 256632., 251304., 253968., 256632., 259296.};
  const std::array<int, 4> in_shape = {{3, 3, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4900.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x2x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {4900.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {9500., 9800.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x2x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {9500., 9800.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {18700., 19000., 19300., 19600.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x2x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {18700., 19000., 19300., 19600.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {9500., 9800.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x2x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {9500., 9800.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {18424., 19000., 19000., 19600.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x2x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {18424., 19000., 19000., 19600.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {36272., 36848., 37424., 38000.,
                                         37400., 38000., 38600., 39200.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x2x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {36272., 36848., 37424., 38000.,
                                         37400., 38000., 38600., 39200.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {18700., 19000., 19300., 19600.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x2x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {18700., 19000., 19300., 19600.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {36272., 37400., 36848., 38000.,
                                         37424., 38600., 38000., 39200.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x2x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {36272., 37400., 36848., 38000.,
                                         37424., 38600., 38000., 39200.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      71416., 72544., 73672., 74800., 72544., 73696., 74848., 76000.,
      73672., 74848., 76024., 77200., 74800., 76000., 77200., 78400.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x2x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      71416., 72544., 73672., 74800., 72544., 73696., 74848., 76000.,
      73672., 74848., 76024., 77200., 74800., 76000., 77200., 78400.};
  const std::array<int, 4> in_shape = {{3, 4, 2, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {16206.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x3x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {16206.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {31746., 32412.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x3x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {31746., 32412.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {62826., 63492., 64158., 64824.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x3x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {62826., 63492., 64158., 64824.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {31746., 32412.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x3x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {31746., 32412.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {62196., 63492., 63492., 64824.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x3x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {62196., 63492., 63492., 64824.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {123096., 124392., 125688., 126984.,
                                         125652., 126984., 128316., 129648.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x3x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {123096., 124392., 125688., 126984.,
                                         125652., 126984., 128316., 129648.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {62826., 63492., 64158., 64824.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x3x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {62826., 63492., 64158., 64824.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {123096., 125652., 124392., 126984.,
                                         125688., 128316., 126984., 129648.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x3x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {123096., 125652., 124392., 126984.,
                                         125688., 128316., 126984., 129648.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      243636., 246192., 248748., 251304., 246192., 248784., 251376., 253968.,
      248748., 251376., 254004., 256632., 251304., 253968., 256632., 259296.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x3x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      243636., 246192., 248748., 251304., 246192., 248784., 251376., 253968.,
      248748., 251376., 254004., 256632., 251304., 253968., 256632., 259296.};
  const std::array<int, 4> in_shape = {{3, 4, 3, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {38024.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x4x1x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {38024.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {74872., 76048.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x4x1x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {74872., 76048.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {148568., 149744., 150920., 152096.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x4x1x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {148568., 149744., 150920., 152096.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 1}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {74872., 76048.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x4x2x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {74872., 76048.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {147440., 149744., 149744., 152096.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x4x2x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {147440., 149744., 149744., 152096.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {292576., 294880., 297184., 299488.,
                                         297136., 299488., 301840., 304192.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x4x2x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {292576., 294880., 297184., 299488.,
                                         297136., 299488., 301840., 304192.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 2}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {148568., 149744., 150920., 152096.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x4x4x1) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {148568., 149744., 150920., 152096.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 1;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {292576., 297136., 294880., 299488.,
                                         297184., 301840., 299488., 304192.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x4x4x2) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {292576., 297136., 294880., 299488.,
                                         297184., 301840., 299488., 304192.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 2;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, SAME3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      580592., 585152., 589712., 594272., 585152., 589760., 594368., 598976.,
      589712., 594368., 599024., 603680., 594272., 598976., 603680., 608384.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::SAME;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}
TYPED_TEST(FilterBackpropWindow1Stride1, VALID3x4x4x4x4) {
  using DataType = typename TestFixture::DataType;
  const std::vector<DataType> exp_out = {
      580592., 585152., 589712., 594272., 585152., 589760., 594368., 598976.,
      589712., 594368., 599024., 603680., 594272., 598976., 603680., 608384.};
  const std::array<int, 4> in_shape = {{3, 4, 4, 4}};
  const int features = 4;
  const auto padding = sycldnn::PaddingMode::VALID;
  const DataType max_input_val = 2048.0;
  this->run_filter_backprop_test(exp_out, in_shape, features, padding,
                                 max_input_val);
}